{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MBl0y2p6LAvC"
      },
      "source": [
        "## 取得数据，并引入基本函数库。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AfPCwCaCLDJX",
        "outputId": "272a53fb-8b27-4eda-faba-6566a63fbb35"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--2024-11-15 14:15:38--  http://www.ehu.eus/ccwintco/uploads/6/67/Indian_pines_corrected.mat\n",
            "Resolving www.ehu.eus (www.ehu.eus)... 158.227.0.65, 2001:720:1410::65\n",
            "Connecting to www.ehu.eus (www.ehu.eus)|158.227.0.65|:80... connected.\n",
            "HTTP request sent, awaiting response... 301 Moved Permanently\n",
            "Location: https://www.ehu.eus/ccwintco/uploads/6/67/Indian_pines_corrected.mat [following]\n",
            "--2024-11-15 14:15:39--  https://www.ehu.eus/ccwintco/uploads/6/67/Indian_pines_corrected.mat\n",
            "Connecting to www.ehu.eus (www.ehu.eus)|158.227.0.65|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 5953527 (5.7M)\n",
            "Saving to: ‘Indian_pines_corrected.mat’\n",
            "\n",
            "Indian_pines_correc 100%[===================>]   5.68M  1.57MB/s    in 3.6s    \n",
            "\n",
            "2024-11-15 14:15:43 (1.57 MB/s) - ‘Indian_pines_corrected.mat’ saved [5953527/5953527]\n",
            "\n",
            "URL transformed to HTTPS due to an HSTS policy\n",
            "--2024-11-15 14:15:43--  https://www.ehu.eus/ccwintco/uploads/c/c4/Indian_pines_gt.mat\n",
            "Resolving www.ehu.eus (www.ehu.eus)... 158.227.0.65, 2001:720:1410::65\n",
            "Connecting to www.ehu.eus (www.ehu.eus)|158.227.0.65|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 1125 (1.1K)\n",
            "Saving to: ‘Indian_pines_gt.mat’\n",
            "\n",
            "Indian_pines_gt.mat 100%[===================>]   1.10K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-11-15 14:15:43 (81.4 MB/s) - ‘Indian_pines_gt.mat’ saved [1125/1125]\n",
            "\n",
            "Collecting spectral\n",
            "  Downloading spectral-0.23.1-py3-none-any.whl.metadata (1.3 kB)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from spectral) (1.26.4)\n",
            "Downloading spectral-0.23.1-py3-none-any.whl (212 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m212.9/212.9 kB\u001b[0m \u001b[31m5.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: spectral\n",
            "Successfully installed spectral-0.23.1\n"
          ]
        }
      ],
      "source": [
        "! wget http://www.ehu.eus/ccwintco/uploads/6/67/Indian_pines_corrected.mat\n",
        "! wget http://www.ehu.eus/ccwintco/uploads/c/c4/Indian_pines_gt.mat\n",
        "! pip install spectral"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "1XN08gjaLjmd"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy.io as sio\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report, cohen_kappa_score\n",
        "import spectral\n",
        "import torch\n",
        "import torchvision\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vHx2iYkNLttk"
      },
      "source": [
        "## 1. 定义 HybridSN 类\n",
        "\n",
        "模型的网络结构为如下图所示：\n",
        "\n",
        "![HybridSN](https://gaopursuit.oss-cn-beijing.aliyuncs.com/202003/20200304203710.jpg)\n",
        "\n",
        "三维卷积部分：\n",
        "\n",
        "- conv1：（1, 30, 25, 25）， 8个 7x3x3 的卷积核 ==>（8, 24, 23, 23）\n",
        "- conv2：（8, 24, 23, 23）， 16个 5x3x3 的卷积核 ==>（16, 20, 21, 21）\n",
        "- conv3：（16, 20, 21, 21），32个 3x3x3 的卷积核 ==>（32, 18, 19, 19）\n",
        "\n",
        "接下来要进行二维卷积，因此把前面的 32*18 reshape 一下，得到 （576, 19, 19）\n",
        "\n",
        "二维卷积：（576, 19, 19） 64个 3x3 的卷积核，得到 （64, 17, 17）\n",
        "\n",
        "接下来是一个 flatten 操作，变为 18496 维的向量，\n",
        "\n",
        "接下来依次为256，128节点的全连接层，都使用比例为0.4的 Dropout，\n",
        "\n",
        "最后输出为 16 个节点，是最终的分类类别数。\n",
        "\n",
        "下面是 HybridSN 类的代码："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "NhsNARbvLz9E"
      },
      "outputs": [],
      "source": [
        "# Indian_pines数据集有16个种类，因此定义class_num=16\n",
        "class_num=16\n",
        "\n",
        "# 定义HybridSN\n",
        "class HybridSN(nn.Module):\n",
        "  def __init__(self, in_channels=1, out_channels=class_num):\n",
        "    super(HybridSN, self).__init__()\n",
        "    # 三维卷积层\n",
        "    self.conv3d = nn.Sequential(\n",
        "        nn.Conv3d(1,8,kernel_size=(7,3,3),stride=1,padding=0),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv3d(8,16,kernel_size=(5,3,3),stride=1,padding=0),\n",
        "        nn.ReLU(),\n",
        "        nn.Conv3d(16,32,kernel_size=(3,3,3),stride=1,padding=0),\n",
        "        nn.ReLU()\n",
        "    )\n",
        "\t# 二维卷积层\n",
        "    self.conv2d = nn.Sequential(\n",
        "        nn.Conv2d(576, 64, kernel_size=(3,3),stride=1,padding=0),\n",
        "        nn.ReLU()\n",
        "    )\n",
        "    # 全连接层\n",
        "    self.fc = nn.Sequential(\n",
        "        nn.Linear(64 * 17 * 17, 256),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(0.4),\n",
        "        nn.Linear(256, 128),\n",
        "        nn.ReLU(),\n",
        "        nn.Dropout(0.4),\n",
        "        nn.Linear(128, 16)\n",
        "    )\n",
        "    # 论文里有加softmax，但本次实验下loss下降特别慢，因此没有使用\n",
        "    # self.softmax = nn.Softmax(dim=1)\n",
        "\n",
        "  # 正向传播过程\n",
        "  def forward(self, t):\n",
        "    t = self.conv3d(t)\n",
        "    # 进行卷积降维\n",
        "    t = t.view(t.shape[0], t.shape[1]*t.shape[2], t.shape[3], t.shape[4])\n",
        "    t = self.conv2d(t)\n",
        "    # 进行卷积降维进行flatten\n",
        "    t = t.view(t.shape[0],-1)\n",
        "    t = self.fc(t)\n",
        "    # t = self.softmax(t)\n",
        "    return t"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eupAaV3VMYre"
      },
      "source": [
        "## 2. 创建数据集\n",
        "\n",
        "首先对高光谱数据实施PCA降维；然后创建 keras 方便处理的数据格式；然后随机抽取 10% 数据做为训练集，剩余的做为测试集。\n",
        "\n",
        "首先定义基本函数："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "vVF8vmy0MZnm"
      },
      "outputs": [],
      "source": [
        "# 对高光谱数据 X 应用 PCA 变换\n",
        "def applyPCA(X, numComponents):\n",
        "    newX = np.reshape(X, (-1, X.shape[2]))\n",
        "    pca = PCA(n_components=numComponents, whiten=True)\n",
        "    newX = pca.fit_transform(newX)\n",
        "    newX = np.reshape(newX, (X.shape[0], X.shape[1], numComponents))\n",
        "    return newX\n",
        "\n",
        "# 对单个像素周围提取 patch 时，边缘像素就无法取了，因此，给这部分像素进行 padding 操作\n",
        "def padWithZeros(X, margin=2):\n",
        "    newX = np.zeros((X.shape[0] + 2 * margin, X.shape[1] + 2* margin, X.shape[2]))\n",
        "    x_offset = margin\n",
        "    y_offset = margin\n",
        "    newX[x_offset:X.shape[0] + x_offset, y_offset:X.shape[1] + y_offset, :] = X\n",
        "    return newX\n",
        "\n",
        "# 在每个像素周围提取 patch ，然后创建成符合 keras 处理的格式\n",
        "def createImageCubes(X, y, windowSize=5, removeZeroLabels = True):\n",
        "    # 给 X 做 padding\n",
        "    margin = int((windowSize - 1) / 2)\n",
        "    zeroPaddedX = padWithZeros(X, margin=margin)\n",
        "    # split patches\n",
        "    patchesData = np.zeros((X.shape[0] * X.shape[1], windowSize, windowSize, X.shape[2]))\n",
        "    patchesLabels = np.zeros((X.shape[0] * X.shape[1]))\n",
        "    patchIndex = 0\n",
        "    for r in range(margin, zeroPaddedX.shape[0] - margin):\n",
        "        for c in range(margin, zeroPaddedX.shape[1] - margin):\n",
        "            patch = zeroPaddedX[r - margin:r + margin + 1, c - margin:c + margin + 1]\n",
        "            patchesData[patchIndex, :, :, :] = patch\n",
        "            patchesLabels[patchIndex] = y[r-margin, c-margin]\n",
        "            patchIndex = patchIndex + 1\n",
        "    if removeZeroLabels:\n",
        "        patchesData = patchesData[patchesLabels>0,:,:,:]\n",
        "        patchesLabels = patchesLabels[patchesLabels>0]\n",
        "        patchesLabels -= 1\n",
        "    return patchesData, patchesLabels\n",
        "\n",
        "def splitTrainTestSet(X, y, testRatio, randomState=345):\n",
        "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=testRatio, random_state=randomState, stratify=y)\n",
        "    return X_train, X_test, y_train, y_test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_wOEBr9uQfAF"
      },
      "source": [
        "下面读取并创建数据集："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8E3W5lKRQgW2",
        "outputId": "8b1e1fbd-ed0d-45f9-f25a-9d8c6b44b671"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hyperspectral data shape:  (145, 145, 200)\n",
            "Label shape:  (145, 145)\n",
            "\n",
            "... ... PCA tranformation ... ...\n",
            "Data shape after PCA:  (145, 145, 30)\n",
            "\n",
            "... ... create data cubes ... ...\n",
            "Data cube X shape:  (10249, 25, 25, 30)\n",
            "Data cube y shape:  (10249,)\n",
            "\n",
            "... ... create train & test data ... ...\n",
            "Xtrain shape:  (1024, 25, 25, 30)\n",
            "Xtest  shape:  (9225, 25, 25, 30)\n",
            "before transpose: Xtrain shape:  (1024, 25, 25, 30, 1)\n",
            "before transpose: Xtest  shape:  (9225, 25, 25, 30, 1)\n",
            "after transpose: Xtrain shape:  (1024, 1, 30, 25, 25)\n",
            "after transpose: Xtest  shape:  (9225, 1, 30, 25, 25)\n"
          ]
        }
      ],
      "source": [
        "# 地物类别\n",
        "class_num = 16\n",
        "X = sio.loadmat('Indian_pines_corrected.mat')['indian_pines_corrected']\n",
        "y = sio.loadmat('Indian_pines_gt.mat')['indian_pines_gt']\n",
        "\n",
        "# 用于测试样本的比例\n",
        "test_ratio = 0.90\n",
        "# 每个像素周围提取 patch 的尺寸\n",
        "patch_size = 25\n",
        "# 使用 PCA 降维，得到主成分的数量\n",
        "pca_components = 30\n",
        "\n",
        "print('Hyperspectral data shape: ', X.shape)\n",
        "print('Label shape: ', y.shape)\n",
        "\n",
        "print('\\n... ... PCA tranformation ... ...')\n",
        "X_pca = applyPCA(X, numComponents=pca_components)\n",
        "print('Data shape after PCA: ', X_pca.shape)\n",
        "\n",
        "print('\\n... ... create data cubes ... ...')\n",
        "X_pca, y = createImageCubes(X_pca, y, windowSize=patch_size)\n",
        "print('Data cube X shape: ', X_pca.shape)\n",
        "print('Data cube y shape: ', y.shape)\n",
        "\n",
        "print('\\n... ... create train & test data ... ...')\n",
        "Xtrain, Xtest, ytrain, ytest = splitTrainTestSet(X_pca, y, test_ratio)\n",
        "print('Xtrain shape: ', Xtrain.shape)\n",
        "print('Xtest  shape: ', Xtest.shape)\n",
        "\n",
        "# 改变 Xtrain, Ytrain 的形状，以符合 keras 的要求\n",
        "Xtrain = Xtrain.reshape(-1, patch_size, patch_size, pca_components, 1)\n",
        "Xtest  = Xtest.reshape(-1, patch_size, patch_size, pca_components, 1)\n",
        "print('before transpose: Xtrain shape: ', Xtrain.shape)\n",
        "print('before transpose: Xtest  shape: ', Xtest.shape)\n",
        "\n",
        "# 为了适应 pytorch 结构，数据要做 transpose\n",
        "Xtrain = Xtrain.transpose(0, 4, 3, 1, 2)\n",
        "Xtest  = Xtest.transpose(0, 4, 3, 1, 2)\n",
        "print('after transpose: Xtrain shape: ', Xtrain.shape)\n",
        "print('after transpose: Xtest  shape: ', Xtest.shape)\n",
        "\n",
        "\n",
        "\"\"\" Training dataset\"\"\"\n",
        "class TrainDS(torch.utils.data.Dataset):\n",
        "    def __init__(self):\n",
        "        self.len = Xtrain.shape[0]\n",
        "        self.x_data = torch.FloatTensor(Xtrain)\n",
        "        self.y_data = torch.LongTensor(ytrain)\n",
        "    def __getitem__(self, index):\n",
        "        # 根据索引返回数据和对应的标签\n",
        "        return self.x_data[index], self.y_data[index]\n",
        "    def __len__(self):\n",
        "        # 返回文件数据的数目\n",
        "        return self.len\n",
        "\n",
        "\"\"\" Testing dataset\"\"\"\n",
        "class TestDS(torch.utils.data.Dataset):\n",
        "    def __init__(self):\n",
        "        self.len = Xtest.shape[0]\n",
        "        self.x_data = torch.FloatTensor(Xtest)\n",
        "        self.y_data = torch.LongTensor(ytest)\n",
        "    def __getitem__(self, index):\n",
        "        # 根据索引返回数据和对应的标签\n",
        "        return self.x_data[index], self.y_data[index]\n",
        "    def __len__(self):\n",
        "        # 返回文件数据的数目\n",
        "        return self.len\n",
        "\n",
        "# 创建 trainloader 和 testloader\n",
        "trainset = TrainDS()\n",
        "testset  = TestDS()\n",
        "train_loader = torch.utils.data.DataLoader(dataset=trainset, batch_size=128, shuffle=True, num_workers=2)\n",
        "test_loader  = torch.utils.data.DataLoader(dataset=testset,  batch_size=128, shuffle=False, num_workers=2)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7UyR1oNaQwkz"
      },
      "source": [
        "## 3. 开始训练"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d-9c5Tihao7X",
        "outputId": "f70dc1c5-f601-4638-a930-675ad2812342"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[Epoch: 1]   [loss avg: 21.2222]   [current loss: 2.5965]\n",
            "[Epoch: 2]   [loss avg: 10.0798]   [current loss: 2.5038]\n",
            "[Epoch: 3]   [loss avg: 6.4931]   [current loss: 2.3536]\n",
            "[Epoch: 4]   [loss avg: 4.6310]   [current loss: 2.2665]\n",
            "[Epoch: 5]   [loss avg: 3.5065]   [current loss: 2.0788]\n",
            "[Epoch: 6]   [loss avg: 2.6885]   [current loss: 1.9607]\n",
            "[Epoch: 7]   [loss avg: 2.1206]   [current loss: 1.8509]\n",
            "[Epoch: 8]   [loss avg: 1.6396]   [current loss: 1.4168]\n",
            "[Epoch: 9]   [loss avg: 1.2803]   [current loss: 1.3411]\n",
            "[Epoch: 10]   [loss avg: 0.9424]   [current loss: 1.1323]\n",
            "[Epoch: 11]   [loss avg: 0.6719]   [current loss: 0.8150]\n",
            "[Epoch: 12]   [loss avg: 0.4846]   [current loss: 0.6978]\n",
            "[Epoch: 13]   [loss avg: 0.3551]   [current loss: 0.5172]\n",
            "[Epoch: 14]   [loss avg: 0.2528]   [current loss: 0.3577]\n",
            "[Epoch: 15]   [loss avg: 0.1752]   [current loss: 0.2645]\n",
            "[Epoch: 16]   [loss avg: 0.1286]   [current loss: 0.1965]\n",
            "[Epoch: 17]   [loss avg: 0.0875]   [current loss: 0.1664]\n",
            "[Epoch: 18]   [loss avg: 0.0950]   [current loss: 0.2768]\n",
            "[Epoch: 19]   [loss avg: 0.0752]   [current loss: 0.1535]\n",
            "[Epoch: 20]   [loss avg: 0.0572]   [current loss: 0.1391]\n",
            "[Epoch: 21]   [loss avg: 0.0505]   [current loss: 0.1085]\n",
            "[Epoch: 22]   [loss avg: 0.0464]   [current loss: 0.1524]\n",
            "[Epoch: 23]   [loss avg: 0.0454]   [current loss: 0.1721]\n",
            "[Epoch: 24]   [loss avg: 0.0291]   [current loss: 0.0845]\n",
            "[Epoch: 25]   [loss avg: 0.0389]   [current loss: 0.0923]\n",
            "[Epoch: 26]   [loss avg: 0.0281]   [current loss: 0.1255]\n",
            "[Epoch: 27]   [loss avg: 0.0230]   [current loss: 0.0172]\n",
            "[Epoch: 28]   [loss avg: 0.0152]   [current loss: 0.0454]\n",
            "[Epoch: 29]   [loss avg: 0.0153]   [current loss: 0.0156]\n",
            "[Epoch: 30]   [loss avg: 0.0125]   [current loss: 0.0402]\n",
            "[Epoch: 31]   [loss avg: 0.0126]   [current loss: 0.0533]\n",
            "[Epoch: 32]   [loss avg: 0.0147]   [current loss: 0.0273]\n",
            "[Epoch: 33]   [loss avg: 0.0131]   [current loss: 0.0109]\n",
            "[Epoch: 34]   [loss avg: 0.0118]   [current loss: 0.0506]\n",
            "[Epoch: 35]   [loss avg: 0.0125]   [current loss: 0.0626]\n",
            "[Epoch: 36]   [loss avg: 0.0092]   [current loss: 0.0562]\n",
            "[Epoch: 37]   [loss avg: 0.0066]   [current loss: 0.0162]\n",
            "[Epoch: 38]   [loss avg: 0.0086]   [current loss: 0.0341]\n",
            "[Epoch: 39]   [loss avg: 0.0083]   [current loss: 0.1284]\n",
            "[Epoch: 40]   [loss avg: 0.0095]   [current loss: 0.0232]\n",
            "[Epoch: 41]   [loss avg: 0.0088]   [current loss: 0.1320]\n",
            "[Epoch: 42]   [loss avg: 0.0054]   [current loss: 0.0078]\n",
            "[Epoch: 43]   [loss avg: 0.0062]   [current loss: 0.0434]\n",
            "[Epoch: 44]   [loss avg: 0.0058]   [current loss: 0.0109]\n",
            "[Epoch: 45]   [loss avg: 0.0062]   [current loss: 0.0277]\n",
            "[Epoch: 46]   [loss avg: 0.0043]   [current loss: 0.0173]\n",
            "[Epoch: 47]   [loss avg: 0.0050]   [current loss: 0.0342]\n",
            "[Epoch: 48]   [loss avg: 0.0032]   [current loss: 0.0373]\n",
            "[Epoch: 49]   [loss avg: 0.0049]   [current loss: 0.0208]\n",
            "[Epoch: 50]   [loss avg: 0.0035]   [current loss: 0.0013]\n",
            "Finished Training\n"
          ]
        }
      ],
      "source": [
        "# 使用GPU训练，可以在菜单 \"代码执行工具\" -> \"更改运行时类型\" 里进行设置\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# 网络放到GPU上\n",
        "net = HybridSN().to(device)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.00037)\n",
        "\n",
        "# 使用记录的训练损失率\n",
        "train_losses = []\n",
        "# 开始训练\n",
        "net.train()\n",
        "for epoch in range(50):\n",
        "    total_loss = 0\n",
        "    for i, (inputs, labels) in enumerate(train_loader):\n",
        "        inputs = inputs.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # 优化器梯度归零\n",
        "        optimizer.zero_grad()\n",
        "        # 正向传播 +　反向传播 + 优化\n",
        "        outputs = net(inputs)\n",
        "\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "    train_losses.append(total_loss / len(train_loader))\n",
        "    print('[Epoch: %d]   [loss avg: %.4f]   [current loss: %.4f]' %(epoch + 1, total_loss/(epoch+1), loss.item()))\n",
        "\n",
        "print('Finished Training')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        },
        "id": "JXs9mTZSa38-",
        "outputId": "33cc8a09-6a8c-485a-edce-feda9f869307"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7e94c1b7b8e0>"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# 可视化训练过程的损失\n",
        "plt.figure(figsize=(12, 5))\n",
        "\n",
        "# 绘制损失图\n",
        "plt.subplot(1, 1, 1)\n",
        "plt.plot(range(1, 51), train_losses, label='Train Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "62K_UFaXcrtT"
      },
      "source": [
        "## 4. 模型测试"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lX_T9jrIcQiw",
        "outputId": "ef126aec-cea0-4314-83c3-d9ae0c5e3ae9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test Accuracy: 0.9689\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "         0.0     0.8857    0.7561    0.8158        41\n",
            "         1.0     0.9860    0.9307    0.9576      1285\n",
            "         2.0     0.9617    0.9746    0.9681       747\n",
            "         3.0     0.9903    0.9577    0.9737       213\n",
            "         4.0     0.9858    0.9563    0.9708       435\n",
            "         5.0     0.9380    0.9893    0.9630       657\n",
            "         6.0     0.9565    0.8800    0.9167        25\n",
            "         7.0     0.9931    0.9977    0.9954       430\n",
            "         8.0     0.8750    0.7778    0.8235        18\n",
            "         9.0     0.9429    0.9817    0.9619       875\n",
            "        10.0     0.9708    0.9778    0.9743      2210\n",
            "        11.0     0.9568    0.9532    0.9550       534\n",
            "        12.0     0.9834    0.9622    0.9727       185\n",
            "        13.0     0.9904    0.9930    0.9917      1139\n",
            "        14.0     0.9423    0.9885    0.9648       347\n",
            "        15.0     0.9306    0.7976    0.8590        84\n",
            "\n",
            "    accuracy                         0.9689      9225\n",
            "   macro avg     0.9556    0.9296    0.9415      9225\n",
            "weighted avg     0.9692    0.9689    0.9687      9225\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# 模型测试\n",
        "count = 0\n",
        "correct_test = 0\n",
        "total_test = 0\n",
        "accuracies = []\n",
        "\n",
        "# 在测试集上计算准确率并预测结果\n",
        "for inputs, labels in test_loader:\n",
        "    inputs = inputs.to(device)\n",
        "    labels = labels.to(device)\n",
        "\n",
        "    outputs = net(inputs)\n",
        "\n",
        "    # 获取预测结果\n",
        "    _, predicted = torch.max(outputs, 1)\n",
        "\n",
        "    # 更新测试准确率\n",
        "    correct_test += (predicted == labels).sum().item()\n",
        "    total_test += labels.size(0)\n",
        "\n",
        "    # 将预测结果添加到y_pred_test\n",
        "    outputs = np.argmax(outputs.detach().cpu().numpy(), axis=1)\n",
        "    if count == 0:\n",
        "        y_pred_test = outputs\n",
        "        count = 1\n",
        "    else:\n",
        "        y_pred_test = np.concatenate((y_pred_test, outputs))\n",
        "\n",
        "    # 计算当前batch的准确率\n",
        "    batch_accuracy = (predicted == labels).sum().item() / labels.size(0)\n",
        "    accuracies.append(batch_accuracy)\n",
        "\n",
        "# 总准确率\n",
        "test_accuracy = correct_test / total_test\n",
        "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n",
        "\n",
        "# 生成分类报告\n",
        "classification = classification_report(ytest, y_pred_test, digits=4)\n",
        "print(classification)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G0ZBYC5scqBr"
      },
      "source": [
        "可视化准确率"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "K_-lmPw9cXDy",
        "outputId": "cb0f7ee1-9009-4da6-ecb4-546b440cbef3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(accuracies, label='Test Accuracy per Batch')\n",
        "plt.axhline(y=test_accuracy, color='r', linestyle='--', label=f'Overall Accuracy: {test_accuracy:.4f}')\n",
        "plt.title('Test Accuracy During Testing')\n",
        "plt.xlabel('Batch Index')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8mqMaVNeKe7"
      },
      "source": [
        "## 显示分类结果"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 538
        },
        "id": "cMIttFBmdvER",
        "outputId": "eff35d9b-2030-4518-e0f0-203506bbbfb0"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "<ipython-input-17-0e9c7a93eab2>:23: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
            "  outputs[i][j] = prediction+1\n",
            "/usr/local/lib/python3.10/dist-packages/spectral/graphics/spypylab.py:796: UserWarning: Failed to create RectangleSelector object. Interactive pixel class labeling will be unavailable.\n",
            "  warnings.warn(msg)\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 500x500 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# load the original image\n",
        "X = sio.loadmat('Indian_pines_corrected.mat')['indian_pines_corrected']\n",
        "y = sio.loadmat('Indian_pines_gt.mat')['indian_pines_gt']\n",
        "\n",
        "height = y.shape[0]\n",
        "width = y.shape[1]\n",
        "\n",
        "X = applyPCA(X, numComponents= pca_components)\n",
        "X = padWithZeros(X, patch_size//2)\n",
        "\n",
        "# 逐像素预测类别\n",
        "outputs = np.zeros((height,width))\n",
        "for i in range(height):\n",
        "    for j in range(width):\n",
        "        if int(y[i,j]) == 0:\n",
        "            continue\n",
        "        else :\n",
        "            image_patch = X[i:i+patch_size, j:j+patch_size, :]\n",
        "            image_patch = image_patch.reshape(1,image_patch.shape[0],image_patch.shape[1], image_patch.shape[2], 1)\n",
        "            X_test_image = torch.FloatTensor(image_patch.transpose(0, 4, 3, 1, 2)).to(device)\n",
        "            prediction = net(X_test_image)\n",
        "            prediction = np.argmax(prediction.detach().cpu().numpy(), axis=1)\n",
        "            outputs[i][j] = prediction+1\n",
        "    # if i % 20 == 0:\n",
        "    #     print('... ... row ', i, ' handling ... ...')\n",
        "\n",
        "predict_image = spectral.imshow(classes = outputs.astype(int),figsize =(5,5))\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
